diff --git a/user_guide/database/active_record.html b/user_guide/database/active_record.html
index 10b018b..f30b3d8 100644
--- a/user_guide/database/active_record.html
+++ b/user_guide/database/active_record.html
@@ -221,7 +221,7 @@
 	
 	<li><strong>Custom key/value method:</strong>
 	
-	<p>You can include an operator in the first parameter in order to to control the comparison:</p>
+	<p>You can include an operator in the first parameter in order to control the comparison:</p>
 	
 	<code>$this->db->where('name !=', $name);<br />
 	$this->db->where('id <', $id);
diff --git a/user_guide/database/fields.html b/user_guide/database/fields.html
index d70314b..1ae1a39 100644
--- a/user_guide/database/fields.html
+++ b/user_guide/database/fields.html
@@ -80,7 +80,7 @@
 }
 </code>
 
-<p>2. You can gather the feild names associated with any query you run by calling the function 
+<p>2. You can gather the field names associated with any query you run by calling the function 
 from your query result object:</p>
 
 <code>
@@ -96,7 +96,7 @@
 
 <h2>$this->db->field_exists()</h2>
 
-<p>Sometimes it's helpful to know whether a particular field exists befor performing an action.
+<p>Sometimes it's helpful to know whether a particular field exists before performing an action.
 Returns a boolean TRUE/FALSE.  Usage example:</p>
 
 <code>
@@ -133,7 +133,7 @@
 }
 </code>
 
-<p>If you have run a query already you can use the result oject instead of supplying the table name:</p>
+<p>If you have run a query already you can use the result object instead of supplying the table name:</p>
 
 <code>
 $query = $this->db->query("YOUR QUERY")<br />
diff --git a/user_guide/database/queries.html b/user_guide/database/queries.html
index 39ad00f..a13e2d6 100644
--- a/user_guide/database/queries.html
+++ b/user_guide/database/queries.html
@@ -87,7 +87,7 @@
 
 <h1>Escaping Queries</h1>
 
-<p>It's a very good security practice to escape your data before sumbiting it into your database. 
+<p>It's a very good security practice to escape your data before submitting it into your database. 
 Code Igniter has two functions that help you do this:</p>
 
 <ol>
diff --git a/user_guide/general/autoloader.html b/user_guide/general/autoloader.html
index a7e907e..36893e9 100644
--- a/user_guide/general/autoloader.html
+++ b/user_guide/general/autoloader.html
@@ -92,7 +92,7 @@
 
 <div id="footer">
 <p>
-Previous Topic:&nbsp;&nbsp;<a href="hooks.html">Hooks - Extneding the Core</a>
+Previous Topic:&nbsp;&nbsp;<a href="hooks.html">Hooks - Extending the Core</a>
 &nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
 <a href="#top">Top of Page</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
 <a href="../index.html">User Guide Home</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
diff --git a/user_guide/general/errors.html b/user_guide/general/errors.html
index 72c9120..16db19e 100644
--- a/user_guide/general/errors.html
+++ b/user_guide/general/errors.html
@@ -112,7 +112,7 @@
 <ol>
 <li>Error Messages.  These are actual errors, such as PHP errors or user errors.</li>
 <li>Debug Messages.  These are messages that assist in debugging. For example, if a class has been initialized, you could log this as debugging info.</li>
-<li>Informational Messages.  These are the lowest priority messages, simply giving information regarding some process.  Code Igniter doesn't natively generate any info messsages but you may want to in your application.</li>
+<li>Informational Messages.  These are the lowest priority messages, simply giving information regarding some process.  Code Igniter doesn't natively generate any info messages but you may want to in your application.</li>
 </ol>
 
 
diff --git a/user_guide/general/helpers.html b/user_guide/general/helpers.html
index a0042b5..089d6d0 100644
--- a/user_guide/general/helpers.html
+++ b/user_guide/general/helpers.html
@@ -76,7 +76,7 @@
 
 <p>Helpers are typically stored in your <dfn>system/helpers</dfn> directory.  Alternately you can create a folder called <kbd>helpers</kbd> inside
 your <kbd>application</kbd> folder and store them there.  Code Igniter will look first in your <dfn>system/application/helpers</dfn>
-directory.  If the direcotry does not exist or the specified helper is not located there CI will instead look in your global 
+directory.  If the directory does not exist or the specified helper is not located there CI will instead look in your global 
 <dfn>system/helpers</dfn> folder.</p>
 
 
diff --git a/user_guide/general/plugins.html b/user_guide/general/plugins.html
index 2e603dd..78b8231 100644
--- a/user_guide/general/plugins.html
+++ b/user_guide/general/plugins.html
@@ -64,12 +64,12 @@
 <h1>Plugins</h1>
 
 <p>Plugins work almost identically to <a href="helpers.html">Helpers</a>.  The main difference is that a plugin usually 
-provides a single function, whereas a Helper is usually a collection of functions.  Helpers are also considerd a part of
+provides a single function, whereas a Helper is usually a collection of functions.  Helpers are also considered a part of
 the core system; plugins are intended to be created and shared by our community.</p>
 
 <p>Plugins should be saved to your <dfn>system/plugins</dfn> directory or you can create a folder called <kbd>plugins</kbd> inside
 your <kbd>application</kbd> folder and store them there.  Code Igniter will look first in your <dfn>system/application/plugins</dfn>
-directory.  If the direcotry does not exist or the specified plugin is not located there CI will instead look in your global 
+directory.  If the directory does not exist or the specified plugin is not located there CI will instead look in your global 
 <dfn>system/plugins</dfn> folder.</p>
 
 
diff --git a/user_guide/general/profiling.html b/user_guide/general/profiling.html
index 42cba04..880aa0c 100644
--- a/user_guide/general/profiling.html
+++ b/user_guide/general/profiling.html
@@ -74,7 +74,7 @@
 
 <h2>Enabling the Profiler</h2>
 
-<p>To enable the profiler place the the following function anywhere within your <a href="controllers.html">Controller</a> functions:</p>
+<p>To enable the profiler place the following function anywhere within your <a href="controllers.html">Controller</a> functions:</p>
 <code>$this->output->enable_profiler(TRUE);</code>
 
 <p>When enabled a report will be generated and inserted at the bottom of your pages.</p>
diff --git a/user_guide/general/urls.html b/user_guide/general/urls.html
index e62ac2f..b3b842d 100644
--- a/user_guide/general/urls.html
+++ b/user_guide/general/urls.html
@@ -112,7 +112,7 @@
 
 <code>www.your-site.com/index.php/products/view/shoes</code>
 
-<p>You can optionaally add a suffix, like <kbd>.html</kbd>, making the page appear to be of a certain type:</p>
+<p>You can optionally add a suffix, like <kbd>.html</kbd>, making the page appear to be of a certain type:</p>
 
 <code>www.your-site.com/index.php/products/view/shoes.html</code>
 
diff --git a/user_guide/general/views.html b/user_guide/general/views.html
index daba759..d4ccb51 100644
--- a/user_guide/general/views.html
+++ b/user_guide/general/views.html
@@ -173,7 +173,7 @@
 
 <p>Then load the page at the URL you've been using and you should see the variables replaced.</p>
 
-<p><strong>Note:</strong> Youl'll notice that in the example above we are using PHP's alternative syntax.  If you
+<p><strong>Note:</strong> You'll notice that in the example above we are using PHP's alternative syntax.  If you
 are not familiar with it you can read about it <a href="alternative_php.html">here</a>.</p>
 
 <h2>Creating Loops</h2>
diff --git a/user_guide/helpers/array_helper.html b/user_guide/helpers/array_helper.html
index 2bd4dc2..a6044be 100644
--- a/user_guide/helpers/array_helper.html
+++ b/user_guide/helpers/array_helper.html
@@ -76,7 +76,7 @@
 <h2>element()</h2>
 
 <p>Lets you fetch an item from an array.  The function tests whether the array index is set and whether it has a value.  If 
-a value exists it is returned.  If a value does not exist it returns FALSE, or whater you've specified as the default value via the third parameter.  Example:</p>
+a value exists it is returned.  If a value does not exist it returns FALSE, or whatever you've specified as the default value via the third parameter.  Example:</p>
 
 <code>
 $array = array('color' => 'red', 'shape' => 'round', 'size' => '');<br />
diff --git a/user_guide/helpers/date_helper.html b/user_guide/helpers/date_helper.html
index 6c21ee0..f787176 100644
--- a/user_guide/helpers/date_helper.html
+++ b/user_guide/helpers/date_helper.html
@@ -206,7 +206,7 @@
 <code>1 Year, 10 Months, 2 Weeks, 5 Days, 10 Hours, 16 Minutes</code>
 
 <p>The first parameter must contain a Unix timestamp.  The second parameter must contain a
-timestamp that is greater that the first timesamp.  If the second parameter empty, the current time will be used.  The most common purpose
+timestamp that is greater that the first timestamp.  If the second parameter empty, the current time will be used.  The most common purpose
 for this function is to show how much time has elapsed from some point in time in the past to now.  Example:</p>
 
 <code>$post_date = '1079621429';<br />
@@ -267,7 +267,7 @@
 
 <p>This menu is useful if you run a membership site in which your users are allowed to set their local timezone value.</p>
 
-<p>The first paramater lets you set the "selected" state of the menu.  For example, to set Pacific time as the default you will do this:</p>
+<p>The first parameter lets you set the "selected" state of the menu.  For example, to set Pacific time as the default you will do this:</p>
 
 <code>echo timezone_menu('UM8');</code>
 
diff --git a/user_guide/helpers/security_helper.html b/user_guide/helpers/security_helper.html
index 516e3c0..d45d7c4 100644
--- a/user_guide/helpers/security_helper.html
+++ b/user_guide/helpers/security_helper.html
@@ -76,7 +76,7 @@
 
 <h2>xss_clean()</h2>
 
-<p>Provides Cross Site Script Hack filtering.  This function is an alias to the the one in the 
+<p>Provides Cross Site Script Hack filtering.  This function is an alias to the one in the 
 <a href="../libraries/input.html">Input class</a>.  More info can be found there.</p>
 
 
diff --git a/user_guide/helpers/string_helper.html b/user_guide/helpers/string_helper.html
index 55cb1ae..ca28dc6 100644
--- a/user_guide/helpers/string_helper.html
+++ b/user_guide/helpers/string_helper.html
@@ -103,7 +103,7 @@
 }<br />
 </code>
 
-<p>You can add as many parameters as you want, and with each each iteration of your loop the next item will be returned.</p>
+<p>You can add as many parameters as you want, and with each iteration of your loop the next item will be returned.</p>
 
 <code>for ($i = 0; $i < 10; $i++)<br />
 {<br />
diff --git a/user_guide/helpers/text_helper.html b/user_guide/helpers/text_helper.html
index 27f6c63..75190da 100644
--- a/user_guide/helpers/text_helper.html
+++ b/user_guide/helpers/text_helper.html
@@ -110,7 +110,7 @@
 
 <p>Converts ASCII values to character entities, including high ASCII and MS Word characters that can cause problems when used in a web page,
 so that they can be shown consistently regardless of browser settings or stored reliably in a database.
-There is some dependance on your server's supported character sets, so it may not be 100% reliable in all cases, but for the most
+There is some dependence on your server's supported character sets, so it may not be 100% reliable in all cases, but for the most
 part it should correctly identify characters outside the normal range (like accented characters). Example:</p>
 
 <code>$string = ascii_to_entities($string);</code>
diff --git a/user_guide/helpers/typography_helper.html b/user_guide/helpers/typography_helper.html
index a95eecc..7213b9d 100644
--- a/user_guide/helpers/typography_helper.html
+++ b/user_guide/helpers/typography_helper.html
@@ -82,7 +82,7 @@
 <ul>
 <li>Surrounds paragraphs within &lt;p&gt;&lt;/p&gt; (looks for double line breaks to identify paragraphs).</li>
 <li>Single line breaks are converted to &lt;br /&gt;, except those that appear within &lt;pre&gt; tags.</li>
-<li>Block level elements, like &lt;div&gt; tags, are are not wrapped within paragraphs, but their contained text is if it contains paragraphs.</li>
+<li>Block level elements, like &lt;div&gt; tags, are not wrapped within paragraphs, but their contained text is if it contains paragraphs.</li>
 <li>Quotes are converted to correctly facing curly quote entities, except those that appear within tags.</li>
 <li>Apostrophes are converted to curly apostrophy entities.</li>
 <li>Double dashes (either like -- this or like--this) are converted to em&#8212;dashes.</li>
diff --git a/user_guide/libraries/config.html b/user_guide/libraries/config.html
index 2797cd2..f8a9f52 100644
--- a/user_guide/libraries/config.html
+++ b/user_guide/libraries/config.html
@@ -151,7 +151,7 @@
 
 <h2>Setting a Config Item</h2>
 
-<p>If you would like to dynamically set a config item or change an existing one, you can so so using:</p>
+<p>If you would like to dynamically set a config item or change an existing one, you can so using:</p>
 
 <code>$this->config->set_item('<var>item_name</var>', '<var>item_value</var>');</code>
 
diff --git a/user_guide/libraries/email.html b/user_guide/libraries/email.html
index 2064a3c..ea1b868 100644
--- a/user_guide/libraries/email.html
+++ b/user_guide/libraries/email.html
@@ -281,7 +281,7 @@
 More text that will be<br />
 wrapped normally.</code>
 
-<p>Place the item you do not want word-wrappd between: <var>{unwrap}</var> <var>{/unwrap}</var>
+<p>Place the item you do not want word-wrapped between: <var>{unwrap}</var> <var>{/unwrap}</var>
 
 
 </div>
diff --git a/user_guide/libraries/encryption.html b/user_guide/libraries/encryption.html
index b27a376..d541174 100644
--- a/user_guide/libraries/encryption.html
+++ b/user_guide/libraries/encryption.html
@@ -75,7 +75,7 @@
 
 <p>A <em>key</em> is a piece of information that controls the cryptographic process and permits an encrypted string to be decoded. 
 In fact, the key you chose will provide the <strong>only</strong> means to decode data that was encrypted with that key,
-so not only must you chose the key carefully, you must must never change it if you intend use it for persistent data.</p>
+so not only must you chose the key carefully, you must never change it if you intend use it for persistent data.</p>
 
 <p>It goes without saying that you should guard your key carefully.
 Should someone gain access to your key, the data will be easily decoded.  If your server is not totally under your control
diff --git a/user_guide/libraries/language.html b/user_guide/libraries/language.html
index 042a1db..1078653 100644
--- a/user_guide/libraries/language.html
+++ b/user_guide/libraries/language.html
@@ -70,7 +70,7 @@
 
 <p>Language files are typically stored in your <dfn>system/language</dfn> directory.  Alternately you can create a folder called <kbd>language</kbd> inside
 your <kbd>application</kbd> folder and store them there.  Code Igniter will look first in your <dfn>system/application/language</dfn>
-directory.  If the direcotry does not exist or the specified language is not located there CI will instead look in your global 
+directory.  If the directory does not exist or the specified language is not located there CI will instead look in your global 
 <dfn>system/language</dfn> folder.</p>
 
 <p class="important"><strong>Note:</strong>&nbsp; Each language should be stored in its own folder.  For example, the English files are located at:
diff --git a/user_guide/libraries/loader.html b/user_guide/libraries/loader.html
index 44bae34..32bbddf 100644
--- a/user_guide/libraries/loader.html
+++ b/user_guide/libraries/loader.html
@@ -83,13 +83,13 @@
 
 <p>Once loaded, the library will be ready for use, using <kbd>$this->email-></kbd><samp><em>some_function</em>()</samp>.
 
-Each library is described in detail in its own page, so please read theinformation regarding each one you would like to use.</p>
+Each library is described in detail in its own page, so please read the information regarding each one you would like to use.</p>
 
 <p>Parameters can be passed to the library via an array in the second parameter. 
 
 
 
-<p>If you would like your libraries assigned to a different variable name then the default you can specify the name in the second paramter:</p>
+<p>If you would like your libraries assigned to a different variable name then the default you can specify the name in the second parameter:</p>
 
 <code>
 $this->load->library('email', 'E'); // Assigns the email object to "E"<br />
diff --git a/user_guide/libraries/output.html b/user_guide/libraries/output.html
index d577fbb..dd3ce42 100644
--- a/user_guide/libraries/output.html
+++ b/user_guide/libraries/output.html
@@ -110,7 +110,7 @@
 <p>Permits you to enable/disable the <a href="../general/profiling.html">Profiler</a>, which will display benchmark and other data
 at the bottom of your pages for debugging and optimization purposes.</p>
 
-<p>To enable the profiler place the the following function anywhere within your <a href="controllers.html">Controller</a> functions:</p>
+<p>To enable the profiler place the following function anywhere within your <a href="controllers.html">Controller</a> functions:</p>
 <code>$this->output->enable_profiler(TRUE);</code>
 
 <p>When enabled a report will be generated and inserted at the bottom of your pages.</p>
diff --git a/user_guide/libraries/pagination.html b/user_guide/libraries/pagination.html
index 19cfc74..317878a 100644
--- a/user_guide/libraries/pagination.html
+++ b/user_guide/libraries/pagination.html
@@ -122,7 +122,7 @@
 
 <h4>$config['num_links'] = 2;</h4>
 
-<p>The number of "digit" links you would like before and after the the selected page number. For example, the number 2 
+<p>The number of "digit" links you would like before and after the selected page number. For example, the number 2 
 will place two digits on either side, as in the example links at the very top of this page.</p>
 
 <h2>Adding Enclosing Markup</h2>
diff --git a/user_guide/libraries/validation.html b/user_guide/libraries/validation.html
index 1af3c32..0a4905a 100644
--- a/user_guide/libraries/validation.html
+++ b/user_guide/libraries/validation.html
@@ -666,8 +666,8 @@
 
 <h2>Dealing with Select Menus, Radio Buttons, and Checkboxes</h2>
 
-<p>If you use select menues, radio buttons or checkboxes, you will want the state of 
-these items to be retained in the event of an error.  The Validation class has three functions taht help you do this:</p>
+<p>If you use select menus, radio buttons or checkboxes, you will want the state of 
+these items to be retained in the event of an error.  The Validation class has three functions that help you do this:</p>
 
 <h2>set_select()</h2>
 
diff --git a/user_guide/libraries/xmlrpc.html b/user_guide/libraries/xmlrpc.html
index 34d47d2..7cd00a2 100644
--- a/user_guide/libraries/xmlrpc.html
+++ b/user_guide/libraries/xmlrpc.html
@@ -82,7 +82,7 @@
 When the XML-RPC Server receives this request it will examine it to determine which class/method should be called to process the request.
 Once processed, the server will then send back a response message.</p>
 
-<p>For detailed spcifications, you can visit the <a href="http://www.xmlrpc.com/">XML-RPC</a> site.</p>
+<p>For detailed specifications, you can visit the <a href="http://www.xmlrpc.com/">XML-RPC</a> site.</p>
 
 <h2>Initializing the Class</h2>
 
@@ -145,7 +145,7 @@
 is referred to as a <dfn>request parameter</dfn>.  The above example has two parameters: 
 The URL and title of your site. When the XML-RPC server receives your request, it will look for parameters it requires.</p>
 
-<p>Request parameters must be placed into an array for transportation, and each parameter can can be one
+<p>Request parameters must be placed into an array for transportation, and each parameter can be one
 of seven data types (strings, numbers, dates, etc.). If your parameters are something other than strings 
 you will have to include the data type in the request array.</p>
 
@@ -447,7 +447,7 @@
 <code>return $this->xmlrpc->send_error_message('123', 'Requested data not available');</code>
 
 <h2>$this->xmlrpc->send_response()</h2>
-<p>Lets you send the response from your server to the client. An array of of valid data values must be sent with this method.</p>
+<p>Lets you send the response from your server to the client. An array of valid data values must be sent with this method.</p>
 <code>$response = array(<br />
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;array(<br />
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;'flerror' => array(FALSE, 'boolean'),<br />
